package supervise;

import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.StringTokenizer;

import utils.Review;

/**
 * Un classifieur ne sachant que construire son dictionnaire. Dérivez cette
 * classe pour faire des classifieurs
 */
public class Classifieur {

	protected ArrayList<String> dictionnaire;

	/**
	 * Construit un dictionnaire à partir de reviews, de mots-outils et d'un
	 * paramètre de filtrage
	 * 
	 * @param reviews
	 *            La liste des reviews du corpus
	 * @param stopWordsFilePath
	 *            Le chemin d'un fichier de mots-outils. Si cette valeur est
	 *            null, aucun mot-outil ne sera utilisé
	 * @param frequenceMax
	 *            La fréquence maximale d'apparition des mots, au delà de
	 *            laquelle le mot ne sera pas ajouté au dictionnaire. La
	 *            fréquence est calculée sur tous les mots du texte sauf les
	 *            mots-outils.
	 */
	protected void construireDictionnaire(ArrayList<Review> reviews,
			String stopWordsFilePath, double frequenceMax) {
		ArrayList<String> stopWords = new ArrayList<String>();
		HashMap<String, Integer> comptes = new HashMap<String, Integer>();
		StringTokenizer tokenizer;
		String token;
		int totalMots = 0;

		dictionnaire = new ArrayList<String>();

		// Si on utilise des stopwords
		if (stopWordsFilePath != null) {
			String mots = "";
			// On ouvre le fichier
			try {
				InputStream input = new FileInputStream(stopWordsFilePath);
				InputStreamReader inputReader = new InputStreamReader(input);
				BufferedReader buffered = new BufferedReader(inputReader);
				String ligne;
				while ((ligne = buffered.readLine()) != null) {
					mots += " " + ligne;
				}
				buffered.close();

				// On extrait tous les mots dans la liste des stopWords
				StringTokenizer st = new StringTokenizer(mots, " \t\n\r\b");
				while (st.hasMoreTokens()) {
					stopWords.add(st.nextToken());
				}
			} catch (IOException ioe) {
				ioe.printStackTrace();
			}
			;
		} // fin stopwords

		// Pour chaque review
		for (Review review : reviews) {
			// On tokenize son texte selon les espaces
			tokenizer = new StringTokenizer(review.getTexte(), " ");
			// Pour chaque mot
			while (tokenizer.hasMoreTokens()) {
				token = tokenizer.nextToken().toLowerCase();
				// S'il y a plus d'un caractere (les autres sont
				// des signes de ponctuation)
				// Et si ce n'est pas dans la liste des stopwords
				if (token.length() > 1 && !stopWords.contains(token)) {
					// S'il n'est pas dans la hashmap
					if (!comptes.containsKey(token)) {
						// On l'ajoute avec compte 1
						comptes.put(token, 1);
					}
					// Si on l'a déjà vu
					else {
						// On le remet avec un compte en plus
						comptes.put(token, comptes.get(token) + 1);
					}
					++totalMots;
				} // pas ponctuation
			} // tous les tokens
		} // toutes les reviews
//		 System.out.println(comptes.size() + " mots representes " + totalMots
//		 + " fois");

		// Au dela de ce nombre, le mot est trop fréquent
		double seuilMax = Math.floor(((double) frequenceMax * totalMots / 100));
//		 System.out.println("S'il est présent plus de " + seuilMax +
//		 " fois, le mot sera retiré");
		// Pour chaque mot
		for (String mot : comptes.keySet()) {
			// Si il ne dépasse pas le seuil
			if (comptes.get(mot) <= seuilMax) {
				// On l'ajoute au dico
				dictionnaire.add(mot);
			}
		}
//		System.out.print(comptes.size() - dictionnaire.size() + "\t");
//		 System.out.println(dictionnaire.size() +
//		 " mots restants dans le dictionnaire");
	} // construireDictionnaire
}
